//-----------------------------------------------------------------------------
//
//	DoorLock.cpp
//
//	Implementation of the Z-Wave COMMAND_CLASS_DOOR_LOCK
//
//	Copyright (c) 2014 Justin Hammond <justin@dynam.ac>
//
//	SOFTWARE NOTICE AND LICENSE
//
//	This file is part of OpenZWave.
//
//	OpenZWave is free software: you can redistribute it and/or modify
//	it under the terms of the GNU Lesser General Public License as published
//	by the Free Software Foundation, either version 3 of the License,
//	or (at your option) any later version.
//
//	OpenZWave is distributed in the hope that it will be useful,
//	but WITHOUT ANY WARRANTY; without even the implied warranty of
//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//	GNU Lesser General Public License for more details.
//
//	You should have received a copy of the GNU Lesser General Public License
//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
//
//-----------------------------------------------------------------------------

#include "command_classes/CommandClasses.h"
#include "command_classes/DoorLock.h"
#include "command_classes/WakeUp.h"
#include "Defs.h"
#include "Msg.h"
#include "Node.h"
#include "Driver.h"
#include "platform/Log.h"

#include "value_classes/ValueBool.h"
#include "value_classes/ValueByte.h"
#include "value_classes/ValueInt.h"

#include "tinyxml.h"

namespace OpenZWave
{
	namespace Internal
	{
		namespace CC
		{

			enum DoorLockCmd
			{
				DoorLockCmd_Set = 0x01,
				DoorLockCmd_Get = 0x02,
				DoorLockCmd_Report = 0x03,
				DoorLockCmd_Configuration_Set = 0x04,
				DoorLockCmd_Configuration_Get = 0x05,
				DoorLockCmd_Configuration_Report = 0x06
			};

			enum TimeOutMode
			{
				DoorLockConfig_NoTimeout = 0x01,
				DoorLockConfig_Timeout = 0x02
			};

			static char const* c_TimeOutModeNames[] =
			{ "No Timeout", "Secure Lock after Timeout" };

			enum DoorLockControlState
			{
				DoorLockControlState_Handle1 = 0x01,
				DoorLockControlState_Handle2 = 0x02,
				DoorLockControlState_Handle3 = 0x04,
				DoorLockControlState_Handle4 = 0x08
			};

			enum DoorLockState
			{
				DoorLockState_Unsecured = 0x00,
				DoorLockState_Unsecured_Timeout = 0x01,
				DoorLockState_Inside_Unsecured = 0x10,
				DoorLockState_Inside_Unsecured_Timeout = 0x11,
				DoorLockState_Outside_Unsecured = 0x20,
				DoorLockState_Outside_Unsecured_Timeout = 0x21,
				DoorLockState_Secured = 0xFF
			};

			static char const* c_LockStateNames[] =
			{ "Unsecure", "Unsecured with Timeout", "Inside Handle Unsecured", "Inside Handle Unsecured with Timeout", "Outside Handle Unsecured", "Outside Handle Unsecured with Timeout", "Secured", "Invalid" };

//-----------------------------------------------------------------------------
// <DoorLock::DoorLock>
// Constructor
//-----------------------------------------------------------------------------
			DoorLock::DoorLock(uint32 const _homeId, uint8 const _nodeId) :
					CommandClass(_homeId, _nodeId)
			{
				m_dom.EnableFlag(STATE_FLAG_DOORLOCK_TIMEOUT, 0);
				m_dom.EnableFlag(STATE_FLAG_DOORLOCK_INSIDEMODE, 0);
				m_dom.EnableFlag(STATE_FLAG_DOORLOCK_OUTSIDEMODE, 0);
				m_dom.EnableFlag(STATE_FLAG_DOORLOCK_TIMEOUTMINS, 0xFE);
				m_dom.EnableFlag(STATE_FLAG_DOORLOCK_TIMEOUTSECS, 0xFE);
				SetStaticRequest(StaticRequest_Values);
			}

//-----------------------------------------------------------------------------
// <DoorLock::RequestState>
// Request current state from the device
//-----------------------------------------------------------------------------
			bool DoorLock::RequestState(uint32 const _requestFlags, uint8 const _instance, Driver::MsgQueue const _queue)
			{
				bool requests = false;
				if ((_requestFlags & RequestFlag_Static) && HasStaticRequest(StaticRequest_Values))
				{
					requests = RequestValue(_requestFlags, ValueID_Index_DoorLock::System_Config_Mode, _instance, _queue);
				}

				if (_requestFlags & RequestFlag_Dynamic)
				{
					requests |= RequestValue(_requestFlags, ValueID_Index_DoorLock::Lock, _instance, _queue);
				}

				return requests;
			}

//-----------------------------------------------------------------------------
// <DoorLock::RequestValue>
// Request current value from the device
//-----------------------------------------------------------------------------
			bool DoorLock::RequestValue(uint32 const _requestFlags, uint16 const _what, uint8 const _instance, Driver::MsgQueue const _queue)
			{
				if (_what >= ValueID_Index_DoorLock::System_Config_Mode)
				{
					Msg* msg = new Msg("DoorLockCmd_Configuration_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId());
					msg->SetInstance(this, _instance);
					msg->Append(GetNodeId());
					msg->Append(2);
					msg->Append(GetCommandClassId());
					msg->Append(DoorLockCmd_Configuration_Get);
					msg->Append(GetDriver()->GetTransmitOptions());
					GetDriver()->SendMsg(msg, _queue);
					return true;

				}
				else if ((_what == ValueID_Index_DoorLock::Lock) || (_what == ValueID_Index_DoorLock::Lock_Mode))
				{

					if (m_com.GetFlagBool(COMPAT_FLAG_GETSUPPORTED))
					{
						Msg* msg = new Msg("DoorLockCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId());
						msg->SetInstance(this, _instance);
						msg->Append(GetNodeId());
						msg->Append(2);
						msg->Append(GetCommandClassId());
						msg->Append(DoorLockCmd_Get);
						msg->Append(GetDriver()->GetTransmitOptions());
						GetDriver()->SendMsg(msg, _queue);
						return true;
					}
					else
					{
						Log::Write(LogLevel_Info, GetNodeId(), "DoorLockCmd_Get Not Supported on this node");
					}
				}
				return false;
			}

//-----------------------------------------------------------------------------
// <DoorLock::HandleMsg>
// Handle a message from the Z-Wave network
//-----------------------------------------------------------------------------
			bool DoorLock::HandleMsg(uint8 const* _data, uint32 const _length, uint32 const _instance	// = 1
					)
			{

				if (DoorLockCmd_Report == (DoorLockCmd) _data[0])
				{
					uint8 lockState = (_data[1] == 0xFF) ? 6 : _data[1];
					if (lockState > 6) /* size of c_LockStateNames minus Invalid Entry */
					{
						Log::Write(LogLevel_Warning, GetNodeId(), "LockState Value was greater than range. Setting to Invalid");
						lockState = 7;
					}

					Log::Write(LogLevel_Info, GetNodeId(), "Received DoorLock report: DoorLock is %s", c_LockStateNames[lockState]);

					if (Internal::VC::ValueBool* value = static_cast<Internal::VC::ValueBool*>(GetValue(_instance, ValueID_Index_DoorLock::Lock)))
					{
						value->OnValueRefreshed(lockState == 0x06);
						value->Release();
					}
					if (Internal::VC::ValueList* value = static_cast<Internal::VC::ValueList*>(GetValue(_instance, ValueID_Index_DoorLock::Lock_Mode)))
					{
						value->OnValueRefreshed(lockState);
						value->Release();
					}
					return true;
				}
				else if (DoorLockCmd_Configuration_Report == (DoorLockCmd) _data[0])
				{
					switch (_data[1])
					{
						case DoorLockConfig_NoTimeout:
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUT, DoorLockConfig_NoTimeout);
							RemoveValue(_instance, ValueID_Index_DoorLock::System_Config_Minutes);
							RemoveValue(_instance, ValueID_Index_DoorLock::System_Config_Seconds);
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTMINS, 0xFE);
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTSECS, 0xFE);
							break;
						case DoorLockConfig_Timeout:
							/* if we have a timeout, then create the Values for the timeout config */
							if (Node* node = GetNodeUnsafe())
							{
								node->CreateValueInt(ValueID::ValueGenre_System, GetCommandClassId(), _instance, ValueID_Index_DoorLock::System_Config_Minutes, "Timeout Minutes", "Mins", false, false, _data[3], 0);
								node->CreateValueInt(ValueID::ValueGenre_System, GetCommandClassId(), _instance, ValueID_Index_DoorLock::System_Config_Seconds, "Timeout Seconds", "Secs", false, false, _data[4], 0);
							}
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUT, DoorLockConfig_Timeout);
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTMINS, _data[3]);
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTSECS, _data[4]);
							break;
						default:
							Log::Write(LogLevel_Warning, GetNodeId(), "Received a Unsupported Door Lock Config Report %d", _data[1]);
					}

					if (Internal::VC::ValueByte* value = static_cast<Internal::VC::ValueByte*>(GetValue(_instance, ValueID_Index_DoorLock::System_Config_OutsideHandles)))
					{
						value->OnValueRefreshed(((_data[2] & 0xF0) >> 4));
						value->Release();
						m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_OUTSIDEMODE, ((_data[2] & 0xF0) >> 4));
					}
					if (Internal::VC::ValueByte* value = static_cast<Internal::VC::ValueByte*>(GetValue(_instance, ValueID_Index_DoorLock::System_Config_InsideHandles)))
					{
						value->OnValueRefreshed((_data[2] & 0x0F));
						value->Release();
						m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_INSIDEMODE, (_data[2] & 0x0F));
					}

					ClearStaticRequest(StaticRequest_Values);
					Log::Write(LogLevel_Info, GetNodeId(), "REcieved DoorLock Config Report: OutsideMode %d, InsideMode %d, Timeout Enabled: %d : %d:%d", ((_data[2] & 0xF0) >> 4), (_data[2] & 0x0F), _data[1], _data[3], _data[4]);
					return true;
				}
				return false;
			}

//-----------------------------------------------------------------------------
// <DoorLock::SetValue>
// Set the lock's state
//-----------------------------------------------------------------------------
			bool DoorLock::SetValue(Internal::VC::Value const& _value)
			{
				uint8 instance = _value.GetID().GetInstance();
				if ((ValueID_Index_DoorLock::Lock == _value.GetID().GetIndex()) && ValueID::ValueType_Bool == _value.GetID().GetType())
				{
					Internal::VC::ValueBool const* value = static_cast<Internal::VC::ValueBool const*>(&_value);

					Log::Write(LogLevel_Info, GetNodeId(), "ValueID_Index_DoorLock::Lock::Set - Requesting lock to be %s", value->GetValue() ? "Locked" : "Unlocked");
					Msg* msg = new Msg("DoorLockCmd_Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId());
					msg->SetInstance(this, _value.GetID().GetInstance());
					msg->Append(GetNodeId());
					msg->Append(3);
					msg->Append(GetCommandClassId());
					msg->Append(DoorLockCmd_Set);
					msg->Append(value->GetValue() ? 0xFF : 0x00);
					msg->Append(GetDriver()->GetTransmitOptions());
					GetDriver()->SendMsg(msg, Driver::MsgQueue_Send);
					return true;
				}
				if ((ValueID_Index_DoorLock::Lock_Mode == _value.GetID().GetIndex()) && (ValueID::ValueType_List == _value.GetID().GetType()))
				{
					Internal::VC::ValueList const* value = static_cast<Internal::VC::ValueList const*>(&_value);
					Internal::VC::ValueList::Item const *item = value->GetItem();
					if (item == NULL)
						return false;

					Log::Write(LogLevel_Info, GetNodeId(), "ValueID_Index_DoorLock::Lock_Mode::Set - Requesting lock to be %s", item->m_label.c_str());
					Msg* msg = new Msg("DoorLockCmd_Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId());
					msg->SetInstance(this, _value.GetID().GetInstance());
					msg->Append(GetNodeId());
					msg->Append(3);
					msg->Append(GetCommandClassId());
					msg->Append(DoorLockCmd_Set);
					msg->Append(item->m_value);
					msg->Append(GetDriver()->GetTransmitOptions());
					GetDriver()->SendMsg(msg, Driver::MsgQueue_Send);
					return true;
				}
				/* if its any of our System Messages.... */
				if (ValueID_Index_DoorLock::System_Config_Mode <= _value.GetID().GetIndex() && ValueID_Index_DoorLock::System_Config_InsideHandles >= _value.GetID().GetIndex())
				{
					bool sendmsg = true;
					switch (_value.GetID().GetIndex())
					{
						/* this is a List */
						case ValueID_Index_DoorLock::System_Config_Mode:
							if (ValueID::ValueType_List != _value.GetID().GetType())
							{
								sendmsg = false;
								break;
							}
							if (Internal::VC::ValueList* value = static_cast<Internal::VC::ValueList*>(GetValue(instance, _value.GetID().GetIndex())))
							{
								Internal::VC::ValueList::Item const *item = (static_cast<Internal::VC::ValueList const*>(&_value))->GetItem();
								if (item != NULL)
									value->OnValueRefreshed(item->m_value);
								value->Release();
							}

							break;

							/* these are a int */
						case ValueID_Index_DoorLock::System_Config_Minutes:
						case ValueID_Index_DoorLock::System_Config_Seconds:
							if (ValueID::ValueType_Int != _value.GetID().GetType())
							{
								sendmsg = false;
								break;
							}
							if (Internal::VC::ValueInt* value = static_cast<Internal::VC::ValueInt*>(GetValue(instance, _value.GetID().GetIndex())))
							{
								value->OnValueRefreshed((static_cast<Internal::VC::ValueInt const*>(&_value))->GetValue());
								value->Release();
							}
							break;
							/* these are a byte */
						case ValueID_Index_DoorLock::System_Config_OutsideHandles:
						case ValueID_Index_DoorLock::System_Config_InsideHandles:
							if (ValueID::ValueType_Byte != _value.GetID().GetType())
							{
								sendmsg = false;
								break;
							}
							if (Internal::VC::ValueByte* value = static_cast<Internal::VC::ValueByte*>(GetValue(instance, _value.GetID().GetIndex())))
							{
								value->OnValueRefreshed((static_cast<Internal::VC::ValueByte const*>(&_value))->GetValue());
								value->Release();
							}
							break;
						default:
							Log::Write(LogLevel_Warning, GetNodeId(), "DoorLock::SetValue - Unhandled System_Config Variable %d", _value.GetID().GetIndex());
							sendmsg = false;
							break;
					}

					if (sendmsg)
					{
						bool ok = true;
						if (Internal::VC::ValueList* value = static_cast<Internal::VC::ValueList*>(GetValue(instance, ValueID_Index_DoorLock::System_Config_Mode)))
						{
							Internal::VC::ValueList::Item const *item = value->GetItem();
							if (item != NULL)
								m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUT, item->m_value);
						}
						else
						{
							ok = false;
							Log::Write(LogLevel_Warning, GetNodeId(), "Failed To Retrieve ValueID_Index_DoorLock::System_Config_Mode For SetValue");
						}
						uint8 control = 0;
						if (Internal::VC::ValueByte* value = static_cast<Internal::VC::ValueByte*>(GetValue(instance, ValueID_Index_DoorLock::System_Config_OutsideHandles)))
						{
							control = (value->GetValue() << 4);
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_INSIDEMODE, control);
						}
						else
						{
							ok = false;
							Log::Write(LogLevel_Warning, GetNodeId(), "Failed To Retrieve ValueID_Index_DoorLock::System_Config_OutsideHandles For SetValue");
						}
						if (Internal::VC::ValueByte* value = static_cast<Internal::VC::ValueByte*>(GetValue(instance, ValueID_Index_DoorLock::System_Config_InsideHandles)))
						{
							control += (value->GetValue() & 0x0F);
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_OUTSIDEMODE, (value->GetValue() & 0x0F));
						}
						else
						{
							ok = false;
							Log::Write(LogLevel_Warning, GetNodeId(), "Failed To Retrieve ValueID_Index_DoorLock::System_Config_InsideHandles For SetValue");
						}
						if (Internal::VC::ValueInt* value = static_cast<Internal::VC::ValueInt*>(GetValue(instance, ValueID_Index_DoorLock::System_Config_Minutes)))
						{
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTMINS, value->GetValue());
						}
						else
						{
							/* Minutes and Seconds Might Not Exist, this is fine. Set to 0xFE */
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTMINS, 0xFE);
						}
						if (Internal::VC::ValueInt* value = static_cast<Internal::VC::ValueInt*>(GetValue(instance, ValueID_Index_DoorLock::System_Config_Seconds)))
						{
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTSECS, value->GetValue());
						}
						else
						{
							/* Minutes and Seconds Might Not Exist, this is fine. Set to 0xFE */
							m_dom.SetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTSECS, 0xFE);
						}
						if (ok)
						{
							Msg* msg = new Msg("DoorLockCmd_Configuration_Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId());
							msg->SetInstance(this, _value.GetID().GetInstance());
							msg->Append(GetNodeId());
							msg->Append(6);
							msg->Append(GetCommandClassId());
							msg->Append(DoorLockCmd_Configuration_Set);
							msg->Append(m_dom.GetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUT));
							msg->Append(control);
							msg->Append(m_dom.GetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTMINS));
							msg->Append(m_dom.GetFlagByte(STATE_FLAG_DOORLOCK_TIMEOUTSECS));
							msg->Append(GetDriver()->GetTransmitOptions());
							GetDriver()->SendMsg(msg, Driver::MsgQueue_Send);
							return true;
						}
						return false;
					}

				}
				return false;
			}

//-----------------------------------------------------------------------------
// <DoorLock::SetValueBasic>
// Update class values based in BASIC mapping
//-----------------------------------------------------------------------------
			void DoorLock::SetValueBasic(uint8 const _instance, uint8 const _value)
			{

				// Send a request for new value to synchronize it with the BASIC set/report.
				// In case the device is sleeping, we set the value anyway so the BASIC set/report
				// stays in sync with it. We must be careful mapping the uint8 BASIC value
				// into a class specific value.
				// When the device wakes up, the real requested value will be retrieved.
				RequestValue(0, DoorLockCmd_Get, _instance, Driver::MsgQueue_Send);
				if (Node* node = GetNodeUnsafe())
				{
					if (WakeUp* wakeUp = static_cast<WakeUp*>(node->GetCommandClass(WakeUp::StaticGetCommandClassId())))
					{
						if (!wakeUp->IsAwake())
						{
							if (Internal::VC::ValueBool* value = static_cast<Internal::VC::ValueBool*>(GetValue(_instance, ValueID_Index_DoorLock::Lock)))
							{
								value->OnValueRefreshed(_value != 0);
								value->Release();
							}
						}
					}
				}
			}

//-----------------------------------------------------------------------------
// <DoorLock::CreateVars>
// Create the values managed by this command class
//-----------------------------------------------------------------------------
			void DoorLock::CreateVars(uint8 const _instance)
			{
				if (Node* node = GetNodeUnsafe())
				{
					node->CreateValueBool(ValueID::ValueGenre_User, GetCommandClassId(), _instance, ValueID_Index_DoorLock::Lock, "Locked", "", false, false, false, 0);

					/* Complex Lock Option */
					{
						vector<Internal::VC::ValueList::Item> items;
						Internal::VC::ValueList::Item item;
						for (uint8 i = 0; i < 8; ++i)
						{
							item.m_label = c_LockStateNames[i];
							item.m_value = (i < 6) ? i : 0xFF;
							items.push_back(item);
						}
						node->CreateValueList(ValueID::ValueGenre_User, GetCommandClassId(), _instance, ValueID_Index_DoorLock::Lock_Mode, "Locked (Advanced)", "", false, false, 1, items, 0, 0);

					}

					/* Timeout mode for Locks that support it */
					{
						vector<Internal::VC::ValueList::Item> items;
						Internal::VC::ValueList::Item item;
						for (uint8 i = 0; i < 2; ++i)
						{
							item.m_label = c_TimeOutModeNames[i];
							item.m_value = i + 1;
							items.push_back(item);
						}
						node->CreateValueList(ValueID::ValueGenre_System, GetCommandClassId(), _instance, ValueID_Index_DoorLock::System_Config_Mode, "Timeout Mode", "", false, false, 1, items, 0, 0);
					}
					node->CreateValueByte(ValueID::ValueGenre_System, GetCommandClassId(), _instance, ValueID_Index_DoorLock::System_Config_OutsideHandles, "Outside Handle Control", "", false, false, 0x0F, 0);
					node->CreateValueByte(ValueID::ValueGenre_System, GetCommandClassId(), _instance, ValueID_Index_DoorLock::System_Config_InsideHandles, "Inside Handle Control", "", false, false, 0x0F, 0);

				}
			}
		} // namespace CC
	} // namespace Internal
} // namespace OpenZWave

